home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Think Class Libraries / TP TCL->CW TCL v1.1.2.3 / UPI ƒ / Updated UPIs ƒ / Printing.p < prev    next >
Text File  |  1996-02-27  |  14KB  |  528 lines
  1. {
  2.      File:        Printing.p
  3.  
  4.      Contains:    Print Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT Printing;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __PRINTING__}
  30. {$SETC __PRINTING__ := 1}
  31.  
  32. {$I+}
  33. {$SETC PrintingIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __ERRORS__}
  38. {$I Errors.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __QUICKDRAW__}
  43. {$I Quickdraw.p}
  44. {$ENDC}
  45. {    Types.p                                                        }
  46. {    MixedMode.p                                                    }
  47. {    QuickdrawText.p                                                }
  48.  
  49. {$IFC UNDEFINED __DIALOGS__}
  50. {$I Dialogs.p}
  51. {$ENDC}
  52. {    Memory.p                                                    }
  53. {    Menus.p                                                        }
  54. {    Controls.p                                                    }
  55. {    Windows.p                                                    }
  56. {        Events.p                                                }
  57. {            OSUtils.p                                            }
  58. {    TextEdit.p                                                    }
  59.  
  60. {$PUSH}
  61. {$ALIGN MAC68K}
  62. {$LibExport+}
  63.  
  64. CONST
  65.     iPFMaxPgs                    = 128;
  66.     iPrPgFract                    = 120;                            {Page scale factor. ptPgSize (below) is in units of 1/iPrPgFract}
  67.     iPrPgFst                    = 1;                            {Page range constants}
  68.     iPrPgMax                    = 9999;
  69.     iPrRelease                    = 3;                            {Current version number of the code.}
  70.     iPrSavPFil                    = -1;
  71.     iPrAbort                    = $0080;
  72.     iPrDevCtl                    = 7;                            {The PrDevCtl Proc's ctl number}
  73.     lPrReset                    = $00010000;                    {The PrDevCtl Proc's CParam for reset}
  74.     lPrLineFeed                    = $00030000;
  75.     lPrLFStd                    = $0003FFFF;                    {The PrDevCtl Proc's CParam for std paper advance}
  76.     lPrLFSixth                    = $0003FFFF;
  77.     lPrPageEnd                    = $00020000;                    {The PrDevCtl Proc's CParam for end page}
  78.     lPrDocOpen                    = $00010000;
  79.     lPrPageOpen                    = $00040000;
  80.     lPrPageClose                = $00020000;
  81.     lPrDocClose                    = $00050000;
  82.     iFMgrCtl                    = 8;                            {The FMgr's Tail-hook Proc's ctl number}
  83.     iMscCtl                        = 9;                            {The FMgr's Tail-hook Proc's ctl number}
  84.     iPvtCtl                        = 10;                            {The FMgr's Tail-hook Proc's ctl number}
  85.  
  86.     pPrGlobals                    = $00000944;                    {The PrVars lo mem area:}
  87.     bDraftLoop                    = 0;
  88.     bSpoolLoop                    = 1;
  89.     bUser1Loop                    = 2;
  90.     bUser2Loop                    = 3;
  91.     fNewRunBit                    = 2;
  92.     fHiResOK                    = 3;
  93.     fWeOpenedRF                    = 4;
  94. {Driver constants }
  95.     iPrBitsCtl                    = 4;
  96.     lScreenBits                    = 0;
  97.     lPaintBits                    = 1;
  98.     lHiScreenBits                = $00000002;                    {The Bitmap Print Proc's Screen Bitmap param}
  99.     lHiPaintBits                = $00000003;                    {The Bitmap Print Proc's Paint [sq pix] param}
  100.     iPrIOCtl                    = 5;
  101.     iPrEvtCtl                    = 6;                            {The PrEvent Proc's ctl number}
  102.     lPrEvtAll                    = $0002FFFD;                    {The PrEvent Proc's CParam for the entire screen}
  103.     lPrEvtTop                    = $0001FFFD;                    {The PrEvent Proc's CParam for the top folder}
  104.     iPrDrvrRef                    = -3;
  105.  
  106.     getRslDataOp                = 4;
  107.     setRslOp                    = 5;
  108.     draftBitsOp                    = 6;
  109.     noDraftBitsOp                = 7;
  110.     getRotnOp                    = 8;
  111.     NoSuchRsl                    = 1;
  112.     OpNotImpl                    = 2;                            {the driver doesn't support this opcode}
  113.     RgType1                        = 1;
  114.  
  115.     feedCut                        = 0;
  116.     feedFanfold                    = 1;
  117.     feedMechCut                    = 2;
  118.     feedOther                    = 3;
  119.  
  120.     
  121. TYPE
  122.     TFeed = SInt8;
  123.  
  124.  
  125. CONST
  126.     scanTB                        = 0;
  127.     scanBT                        = 1;
  128.     scanLR                        = 2;
  129.     scanRL                        = 3;
  130.  
  131.     
  132. TYPE
  133.     TScan = SInt8;
  134.  
  135. { A Rect Ptr }
  136.     TPRect = ^Rect;
  137.  
  138. {$IFC MWERKS & PROCTYPE}
  139.     PrIdleProcPtr = PROCEDURE;
  140. {$ELSEC}
  141.     PrIdleProcPtr = ProcPtr;  { PROCEDURE PrIdle; }
  142. {$ENDC}
  143.  
  144.     PrIdleUPP = UniversalProcPtr;
  145.  
  146. CONST
  147.     uppPrIdleProcInfo = $00000000; { PROCEDURE ; }
  148.  
  149. FUNCTION NewPrIdleProc(userRoutine: PrIdleProcPtr): PrIdleUPP;
  150.     {$IFC NOT GENERATINGCFM }
  151.     INLINE $2E9F;
  152.     {$ENDC}
  153.  
  154. PROCEDURE CallPrIdleProc(userRoutine: PrIdleUPP);
  155.     {$IFC NOT GENERATINGCFM}
  156.     INLINE $205F, $4E90;
  157.     {$ENDC}
  158. TYPE
  159. {$IFC MWERKS & PROCTYPE}
  160.     PItemProcPtr = PROCEDURE (theDialog: DialogPtr; item: INTEGER);
  161. {$ELSEC}
  162.     PItemProcPtr = ProcPtr;  { PROCEDURE PItem(theDialog: DialogPtr; item: INTEGER); }
  163. {$ENDC}
  164.  
  165.     PItemUPP = UniversalProcPtr;
  166.  
  167. CONST
  168.     uppPItemProcInfo = $000002C0; { PROCEDURE (4 byte param, 2 byte param); }
  169.  
  170. FUNCTION NewPItemProc(userRoutine: PItemProcPtr): PItemUPP;
  171.     {$IFC NOT GENERATINGCFM }
  172.     INLINE $2E9F;
  173.     {$ENDC}
  174.  
  175. PROCEDURE CallPItemProc(theDialog: DialogPtr; item: INTEGER; userRoutine: PItemUPP);
  176.     {$IFC NOT GENERATINGCFM}
  177.     INLINE $205F, $4E90;
  178.     {$ENDC}
  179.  
  180. TYPE
  181.     TPrPort = RECORD
  182.         gPort:                    GrafPort;                                {The Printer's graf port.}
  183.         gProcs:                    QDProcs;                                {..and its procs}
  184.         lGParam1:                LONGINT;                                {16 bytes for private parameter storage.}
  185.         lGParam2:                LONGINT;
  186.         lGParam3:                LONGINT;
  187.         lGParam4:                LONGINT;
  188.         fOurPtr:                BOOLEAN;                                {Whether the PrPort allocation was done by us.}
  189.         fOurBits:                BOOLEAN;                                {Whether the BitMap allocation was done by us.}
  190.     END;
  191.  
  192.     TPPrPort = ^TPrPort;
  193.  
  194. { Printing Graf Port. All printer imaging, whether spooling, banding, etc, happens "thru" a GrafPort.
  195.   This is the "PrPeek" record. }
  196.     TPrInfo = RECORD
  197.         iDev:                    INTEGER;                                {Font mgr/QuickDraw device code}
  198.         iVRes:                    INTEGER;                                {Resolution of device, in device coordinates}
  199.         iHRes:                    INTEGER;                                {..note: V before H => compatable with Point.}
  200.         rPage:                    Rect;                                    {The page (printable) rectangle in device coordinates.}
  201.     END;
  202.  
  203.     TPPrInfo = ^TPrInfo;
  204.  
  205. { Print Info Record: The parameters needed for page composition. }
  206.     TPrStl = RECORD
  207.         wDev:                    INTEGER;
  208.         iPageV:                    INTEGER;
  209.         iPageH:                    INTEGER;
  210.         bPort:                    SInt8;
  211.         feed:                    TFeed;
  212.     END;
  213.  
  214.     TPPrStl = ^TPrStl;
  215.  
  216.     TPrXInfo = RECORD
  217.         iRowBytes:                INTEGER;
  218.         iBandV:                    INTEGER;
  219.         iBandH:                    INTEGER;
  220.         iDevBytes:                INTEGER;
  221.         iBands:                    INTEGER;
  222.         bPatScale:                SInt8;
  223.         bUlThick:                SInt8;
  224.         bUlOffset:                SInt8;
  225.         bUlShadow:                SInt8;
  226.         scan:                    TScan;
  227.         bXInfoX:                SInt8;
  228.     END;
  229.  
  230.     TPPrXInfo = ^TPrXInfo;
  231.  
  232.     TPrJob = RECORD
  233.         iFstPage:                INTEGER;                                {Page Range.}
  234.         iLstPage:                INTEGER;
  235.         iCopies:                INTEGER;                                {No. copies.}
  236.         bJDocLoop:                SInt8;                                    {The Doc style: Draft, Spool, .., and ..}
  237.         fFromUsr:                BOOLEAN;                                {Printing from an User's App (not PrApp) flag}
  238.         pIdleProc:                PrIdleUPP;                                {The Proc called while waiting on IO etc.}
  239.         pFileName:                StringPtr;                                {Spool File Name: NIL for default.}
  240.         iFileVol:                INTEGER;                                {Spool File vol, set to 0 initially}
  241.         bFileVers:                SInt8;                                    {Spool File version, set to 0 initially}
  242.         bJobX:                    SInt8;                                    {An eXtra byte.}
  243.     END;
  244.  
  245.     TPPrJob = ^TPrJob;
  246.  
  247. { Print Job: Print "form" for a single print request. }
  248.     TPrFlag1 = PACKED RECORD
  249.         f15:                    BOOLEAN;
  250.         f14:                    BOOLEAN;
  251.         f13:                    BOOLEAN;
  252.         f12:                    BOOLEAN;
  253.         f11:                    BOOLEAN;
  254.         f10:                    BOOLEAN;
  255.         f9:                        BOOLEAN;
  256.         f8:                        BOOLEAN;
  257.         f7:                        BOOLEAN;
  258.         f6:                        BOOLEAN;
  259.         f5:                        BOOLEAN;
  260.         f4:                        BOOLEAN;
  261.         f3:                        BOOLEAN;
  262.         f2:                        BOOLEAN;
  263.         fLstPgFst:                BOOLEAN;
  264.         fUserScale:                BOOLEAN;
  265.     END;
  266.  
  267.     TPrint = RECORD
  268.         iPrVersion:                INTEGER;                                {(2) Printing software version}
  269.         prInfo:                    TPrInfo;                                {(14) the PrInfo data associated with the current style.}
  270.         rPaper:                    Rect;                                    {(8) The paper rectangle [offset from rPage]}
  271.         prStl:                    TPrStl;                                    {(8)  This print request's style.}
  272.         prInfoPT:                TPrInfo;                                {(14)  Print Time Imaging metrics}
  273.         prXInfo:                TPrXInfo;                                {(16)  Print-time (expanded) Print info record.}
  274.         prJob:                    TPrJob;                                    {(20) The Print Job request (82)  Total of the above; 120-82 = 38 bytes needed to fill 120}
  275.         CASE INTEGER OF
  276.         0: (
  277.             printX:                        ARRAY [1..19] OF INTEGER;
  278.            );
  279.         1: (
  280.             prFlag1:                    TPrFlag1;
  281.             iZoomMin:                    INTEGER;
  282.             iZoomMax:                    INTEGER;
  283.             hDocName:                    StringHandle;
  284.            );
  285.     END;
  286.  
  287.     TPPrint = ^TPrint;
  288.     THPrint = ^TPPrint;
  289.  
  290. { The universal 120 byte printing record }
  291.     TPrStatus = RECORD
  292.         iTotPages:                INTEGER;                                {Total pages in Print File.}
  293.         iCurPage:                INTEGER;                                {Current page number}
  294.         iTotCopies:                INTEGER;                                {Total copies requested}
  295.         iCurCopy:                INTEGER;                                {Current copy number}
  296.         iTotBands:                INTEGER;                                {Total bands per page.}
  297.         iCurBand:                INTEGER;                                {Current band number}
  298.         fPgDirty:                BOOLEAN;                                {True if current page has been written to.}
  299.         fImaging:                BOOLEAN;                                {Set while in band's DrawPic call.}
  300.         hPrint:                    THPrint;                                {Handle to the active Printer record}
  301.         pPrPort:                TPPrPort;                                {Ptr to the active PrPort}
  302.         hPic:                    PicHandle;                                {Handle to the active Picture}
  303.     END;
  304.  
  305.     TPPrStatus = ^TPrStatus;
  306.  
  307. { Print Status: Print information during printing. }
  308.     TPfPgDir = RECORD
  309.         iPages:                    INTEGER;
  310.         iPgPos:                    ARRAY [0..128] OF LONGINT;                {ARRAY [0..iPfMaxPgs] OF LONGINT}
  311.     END;
  312.  
  313.     TPPfPgDir = ^TPfPgDir;
  314.     THPfPgDir = ^TPPfPgDir;
  315.  
  316. { PicFile = a TPfHeader followed by n QuickDraw Pics (whose PicSize is invalid!) }
  317. { This is the Printing Dialog Record. Only used by folks appending their own
  318.    DITLs to the print dialogs.    Print Dialog: The Dialog Stream object. }
  319. {$IFC STRICT_WINDOWS }
  320.     TPPrDlgRef = Ptr;
  321. {$ELSEC}
  322.     TPrDlg = RECORD
  323.         Dlg:                    DialogRecord;                            {The Dialog window}
  324.         pFltrProc:                ModalFilterUPP;                            {The Filter Proc.}
  325.         pItemProc:                PItemUPP;                                {The Item evaluating proc.}
  326.         hPrintUsr:                THPrint;                                {The user's print record.}
  327.         fDoIt:                    BOOLEAN;
  328.         fDone:                    BOOLEAN;
  329.         lUser1:                    LONGINT;                                {Four longs for apps to hang global data.}
  330.         lUser2:                    LONGINT;                                {Plus more stuff needed by the particular}
  331.         lUser3:                    LONGINT;                                {printing dialog.}
  332.         lUser4:                    LONGINT;
  333.     END;
  334.  
  335.     TPPrDlg = ^TPrDlg;
  336.  
  337.     { MWERKS TPPrDlgRef = ^TPrDlg;}
  338.     TPPrDlgRef = TPPrDlg;
  339.  
  340. {$ENDC}
  341.  
  342. {$IFC MWERKS & PROCTYPE}
  343.     PDlgInitProcPtr = FUNCTION (hPrint: THPrint): TPPrDlgRef;
  344. {$ELSEC}
  345.     PDlgInitProcPtr = ProcPtr;  { FUNCTION PDlgInit(hPrint: THPrint): TPPrDlgRef; }
  346. {$ENDC}
  347.  
  348.     PDlgInitUPP = UniversalProcPtr;
  349.  
  350. CONST
  351.     uppPDlgInitProcInfo = $000000F0; { FUNCTION (4 byte param): 4 byte result; }
  352.  
  353. FUNCTION NewPDlgInitProc(userRoutine: PDlgInitProcPtr): PDlgInitUPP;
  354.     {$IFC NOT GENERATINGCFM }
  355.     INLINE $2E9F;
  356.     {$ENDC}
  357.  
  358. FUNCTION CallPDlgInitProc(hPrint: THPrint; userRoutine: PDlgInitUPP): TPPrDlgRef;
  359.     {$IFC NOT GENERATINGCFM}
  360.     INLINE $205F, $4E90;
  361.     {$ENDC}
  362.  
  363. TYPE
  364.     TGnlData = RECORD
  365.         iOpCode:                INTEGER;
  366.         iError:                    INTEGER;
  367.         lReserved:                LONGINT;                                {more fields here depending on call}
  368.     END;
  369.  
  370.     TRslRg = RECORD
  371.         iMin:                    INTEGER;
  372.         iMax:                    INTEGER;
  373.     END;
  374.  
  375.     TRslRec = RECORD
  376.         iXRsl:                    INTEGER;
  377.         iYRsl:                    INTEGER;
  378.     END;
  379.  
  380.     TGetRslBlk = RECORD
  381.         iOpCode:                INTEGER;
  382.         iError:                    INTEGER;
  383.         lReserved:                LONGINT;
  384.         iRgType:                INTEGER;
  385.         xRslRg:                    TRslRg;
  386.         yRslRg:                    TRslRg;
  387.         iRslRecCnt:                INTEGER;
  388.         rgRslRec:                ARRAY [1..27] OF TRslRec;
  389.     END;
  390.  
  391.     TSetRslBlk = RECORD
  392.         iOpCode:                INTEGER;
  393.         iError:                    INTEGER;
  394.         lReserved:                LONGINT;
  395.         hPrint:                    THPrint;
  396.         iXRsl:                    INTEGER;
  397.         iYRsl:                    INTEGER;
  398.     END;
  399.  
  400.     TDftBitsBlk = RECORD
  401.         iOpCode:                INTEGER;
  402.         iError:                    INTEGER;
  403.         lReserved:                LONGINT;
  404.         hPrint:                    THPrint;
  405.     END;
  406.  
  407.     TGetRotnBlk = RECORD
  408.         iOpCode:                INTEGER;
  409.         iError:                    INTEGER;
  410.         lReserved:                LONGINT;
  411.         hPrint:                    THPrint;
  412.         fLandscape:                BOOLEAN;
  413.         bXtra:                    SInt8;
  414.     END;
  415.  
  416.  
  417. PROCEDURE PrPurge;
  418.     {$IFC NOT GENERATINGCFM}
  419.     INLINE $2F3C, $A800, $0000, $A8FD;
  420.     {$ENDC}
  421. PROCEDURE PrNoPurge;
  422.     {$IFC NOT GENERATINGCFM}
  423.     INLINE $2F3C, $B000, $0000, $A8FD;
  424.     {$ENDC}
  425. PROCEDURE PrOpen;
  426.     {$IFC NOT GENERATINGCFM}
  427.     INLINE $2F3C, $C800, $0000, $A8FD;
  428.     {$ENDC}
  429. PROCEDURE PrClose;
  430.     {$IFC NOT GENERATINGCFM}
  431.     INLINE $2F3C, $D000, $0000, $A8FD;
  432.     {$ENDC}
  433. PROCEDURE PrintDefault(hPrint: THPrint);
  434.     {$IFC NOT GENERATINGCFM}
  435.     INLINE $2F3C, $2004, $0480, $A8FD;
  436.     {$ENDC}
  437. FUNCTION PrValidate(hPrint: THPrint): BOOLEAN;
  438.     {$IFC NOT GENERATINGCFM}
  439.     INLINE $2F3C, $5204, $0498, $A8FD;
  440.     {$ENDC}
  441. FUNCTION PrStlDialog(hPrint: THPrint): BOOLEAN;
  442.     {$IFC NOT GENERATINGCFM}
  443.     INLINE $2F3C, $2A04, $0484, $A8FD;
  444.     {$ENDC}
  445. FUNCTION PrJobDialog(hPrint: THPrint): BOOLEAN;
  446.     {$IFC NOT GENERATINGCFM}
  447.     INLINE $2F3C, $3204, $0488, $A8FD;
  448.     {$ENDC}
  449. FUNCTION PrStlInit(hPrint: THPrint): TPPrDlgRef;
  450.     {$IFC NOT GENERATINGCFM}
  451.     INLINE $2F3C, $3C04, $040C, $A8FD;
  452.     {$ENDC}
  453. FUNCTION PrJobInit(hPrint: THPrint): TPPrDlgRef;
  454.     {$IFC NOT GENERATINGCFM}
  455.     INLINE $2F3C, $4404, $0410, $A8FD;
  456.     {$ENDC}
  457. PROCEDURE PrJobMerge(hPrintSrc: THPrint; hPrintDst: THPrint);
  458.     {$IFC NOT GENERATINGCFM}
  459.     INLINE $2F3C, $5804, $089C, $A8FD;
  460.     {$ENDC}
  461. FUNCTION PrDlgMain(hPrint: THPrint; pDlgInit: PDlgInitUPP): BOOLEAN;
  462.     {$IFC NOT GENERATINGCFM}
  463.     INLINE $2F3C, $4A04, $0894, $A8FD;
  464.     {$ENDC}
  465. FUNCTION PrOpenDoc(hPrint: THPrint; pPrPort: TPPrPort; pIOBuf: Ptr): TPPrPort;
  466.     {$IFC NOT GENERATINGCFM}
  467.     INLINE $2F3C, $0400, $0C00, $A8FD;
  468.     {$ENDC}
  469. PROCEDURE PrCloseDoc(pPrPort: TPPrPort);
  470.     {$IFC NOT GENERATINGCFM}
  471.     INLINE $2F3C, $0800, $0484, $A8FD;
  472.     {$ENDC}
  473. PROCEDURE PrOpenPage(pPrPort: TPPrPort; pPageFrame: TPRect);
  474.     {$IFC NOT GENERATINGCFM}
  475.     INLINE $2F3C, $1000, $0808, $A8FD;
  476.     {$ENDC}
  477. PROCEDURE PrClosePage(pPrPort: TPPrPort);
  478.     {$IFC NOT GENERATINGCFM}
  479.     INLINE $2F3C, $1800, $040C, $A8FD;
  480.     {$ENDC}
  481. PROCEDURE PrPicFile(hPrint: THPrint; pPrPort: TPPrPort; pIOBuf: Ptr; pDevBuf: Ptr; VAR prStatus: TPrStatus);
  482.     {$IFC NOT GENERATINGCFM}
  483.     INLINE $2F3C, $6005, $1480, $A8FD;
  484.     {$ENDC}
  485. FUNCTION PrError: INTEGER;
  486.     {$IFC NOT GENERATINGCFM}
  487.     INLINE $2F3C, $BA00, $0000, $A8FD;
  488.     {$ENDC}
  489. PROCEDURE PrSetError(iErr: INTEGER);
  490.     {$IFC NOT GENERATINGCFM}
  491.     INLINE $2F3C, $C000, $0200, $A8FD;
  492.     {$ENDC}
  493. PROCEDURE PrGeneral(pData: Ptr);
  494.     {$IFC NOT GENERATINGCFM}
  495.     INLINE $2F3C, $7007, $0480, $A8FD;
  496.     {$ENDC}
  497. PROCEDURE PrDrvrOpen;
  498.     {$IFC NOT GENERATINGCFM}
  499.     INLINE $2F3C, $8000, $0000, $A8FD;
  500.     {$ENDC}
  501. PROCEDURE PrDrvrClose;
  502.     {$IFC NOT GENERATINGCFM}
  503.     INLINE $2F3C, $8800, $0000, $A8FD;
  504.     {$ENDC}
  505. PROCEDURE PrCtlCall(iWhichCtl: INTEGER; lParam1: LONGINT; lParam2: LONGINT; lParam3: LONGINT);
  506.     {$IFC NOT GENERATINGCFM}
  507.     INLINE $2F3C, $A000, $0E00, $A8FD;
  508.     {$ENDC}
  509. FUNCTION PrDrvrDCE: Handle;
  510.     {$IFC NOT GENERATINGCFM}
  511.     INLINE $2F3C, $9400, $0000, $A8FD;
  512.     {$ENDC}
  513. FUNCTION PrDrvrVers: INTEGER;
  514.     {$IFC NOT GENERATINGCFM}
  515.     INLINE $2F3C, $9A00, $0000, $A8FD;
  516.     {$ENDC}
  517.  
  518. {$ALIGN RESET}
  519. {$POP}
  520.  
  521. {$SETC UsingIncludes := PrintingIncludes}
  522.  
  523. {$ENDC} {__PRINTING__}
  524.  
  525. {$IFC NOT UsingIncludes}
  526.  END.
  527. {$ENDC}
  528.